MAYBE

We are left with following problem, upon which TcT provides the
certificate MAYBE.

Strict Trs:
  { g(X) -> h(activate(X))
  , h(n__d()) -> g(n__c())
  , activate(X) -> X
  , activate(n__d()) -> d()
  , activate(n__c()) -> c()
  , c() -> d()
  , c() -> n__c()
  , d() -> n__d() }
Obligation:
  innermost runtime complexity
Answer:
  MAYBE

We use the processor 'matrix interpretation of dimension 1' to
orient following rules strictly.

Trs:
  { activate(X) -> X
  , activate(n__d()) -> d()
  , c() -> n__c() }

The induced complexity on above rules (modulo remaining rules) is
YES(?,O(n^1)) . These rules are moved into the corresponding weak
component(s).

Sub-proof:
----------
  TcT has computed the following constructor-based matrix
  interpretation satisfying not(EDA).
  
           [g](x1) = [2] x1 + [2]
                                 
           [h](x1) = [2] x1 + [0]
                                 
    [activate](x1) = [1] x1 + [1]
                                 
               [c] = [2]         
                                 
               [d] = [2]         
                                 
            [n__d] = [2]         
                                 
            [n__c] = [1]         
  
  This order satisfies the following ordering constraints:
  
                [g(X)] =  [2] X + [2]     
                       >= [2] X + [2]     
                       =  [h(activate(X))]
                                          
           [h(n__d())] =  [4]             
                       >= [4]             
                       =  [g(n__c())]     
                                          
         [activate(X)] =  [1] X + [1]     
                       >  [1] X + [0]     
                       =  [X]             
                                          
    [activate(n__d())] =  [3]             
                       >  [2]             
                       =  [d()]           
                                          
    [activate(n__c())] =  [2]             
                       >= [2]             
                       =  [c()]           
                                          
                 [c()] =  [2]             
                       >= [2]             
                       =  [d()]           
                                          
                 [c()] =  [2]             
                       >  [1]             
                       =  [n__c()]        
                                          
                 [d()] =  [2]             
                       >= [2]             
                       =  [n__d()]        
                                          

We return to the main proof.

We are left with following problem, upon which TcT provides the
certificate MAYBE.

Strict Trs:
  { g(X) -> h(activate(X))
  , h(n__d()) -> g(n__c())
  , activate(n__c()) -> c()
  , c() -> d()
  , d() -> n__d() }
Weak Trs:
  { activate(X) -> X
  , activate(n__d()) -> d()
  , c() -> n__c() }
Obligation:
  innermost runtime complexity
Answer:
  MAYBE

Empty strict component of the problem is NOT empty.

Arrrr..